/**
 * 日期工具函数
 */

/**
 * 计算两个日期之间的月份差
 * @param {string} startDate - 开始日期，格式：YYYY/MM/DD 或 YYYY/MM
 * @param {string} endDate - 结束日期，格式：YYYY/MM/DD 或 YYYY/MM
 * @returns {string} 返回月份差的字符串，格式：(X个月)
 */
export function getMonthDiff(startDate, endDate) {
  // 判断startDate, endDate不为空，否则返回''
  if (!startDate || !endDate) {
    return "";
  }

  // 确保输入是字符串类型
  const startStr = String(startDate).trim();
  const endStr = String(endDate).trim();

  if (!startStr || !endStr) {
    return "";
  }

  // 辅助函数：清理日期字符串，确保跨浏览器兼容
  const cleanDateString = (dateStr) => {
    // 移除时间部分（如果存在），只保留日期
    const datePart = dateStr.split(" ")[0].trim();
    // 统一转换为斜杠格式（跨浏览器兼容性最好）
    return datePart.replace(/-/g, "/");
  };

  // 清理日期字符串
  const cleanedStart = cleanDateString(startStr);
  const cleanedEnd = cleanDateString(endStr);

  // 判断日期是否包含天数（统一按斜杠分割）
  const startHasDay = cleanedStart.split("/").length === 3;
  const endHasDay = cleanedEnd.split("/").length === 3;

  let start, end;

  // 处理没有天数的情况
  if (!startHasDay) {
    start = new Date(cleanedStart + "/01"); // 假设第一个日期为月初
  } else {
    start = new Date(cleanedStart); // 使用完整日期
  }

  if (!endHasDay) {
    // 假设第二个日期为月末
    end = new Date(cleanedEnd + "/01");
    end.setMonth(end.getMonth() + 1); // 将月份加一
    end.setDate(0); // 设置为该月的最后一天
  } else {
    end = new Date(cleanedEnd); // 使用完整日期
  }

  // 检查日期是否有效（防止NaN）
  if (isNaN(start.getTime()) || isNaN(end.getTime())) {
    console.error("日期解析失败:", {
      原始输入: { startDate, endDate },
      清理后: { cleanedStart, cleanedEnd },
      Date对象: { start, end }
    });
    return "";
  }

  // 获取年、月、日
  const startYear = start.getFullYear();
  const startMonth = start.getMonth();
  const startDay = start.getDate();

  const endYear = end.getFullYear();
  const endMonth = end.getMonth();
  const endDay = end.getDate();

  // 计算年月差
  let yearDiff = endYear - startYear;
  let monthDiff = endMonth - startMonth + 1;

  // 计算总月差
  let totalMonths = yearDiff * 12 + monthDiff;

  // 如果第二个日期的日子早于第一个日期的日子，月份差减去1
  if (endDay < startDay) {
    totalMonths--;
  }

  // 如果月份差小于1，计算天数差
  if (totalMonths <= 0) {
    const daysDiff = Math.ceil((end - start) / (1000 * 60 * 60 * 24));
    return `(${daysDiff}天)`;
  }

  // 根据月差返回相应结果
  return `(${totalMonths}个月)`;
}

/**
 * 格式化日期
 * @param {Date|string} date - 日期对象或日期字符串
 * @param {string} format - 格式化模板，如 'YYYY-MM-DD'
 * @returns {string} 格式化后的日期字符串
 */
export function formatDate(date, format = "YYYY-MM-DD") {
  if (!date) return "";

  const d = new Date(date);
  if (isNaN(d.getTime())) return "";

  const year = d.getFullYear();
  const month = String(d.getMonth() + 1).padStart(2, "0");
  const day = String(d.getDate()).padStart(2, "0");
  const hours = String(d.getHours()).padStart(2, "0");
  const minutes = String(d.getMinutes()).padStart(2, "0");
  const seconds = String(d.getSeconds()).padStart(2, "0");

  return format
    .replace("YYYY", year)
    .replace("MM", month)
    .replace("DD", day)
    .replace("HH", hours)
    .replace("mm", minutes)
    .replace("ss", seconds);
}

/**
 * 获取日期范围内的天数
 * @param {string|Date} startDate - 开始日期
 * @param {string|Date} endDate - 结束日期
 * @returns {number} 天数差
 */
export function getDaysDiff(startDate, endDate) {
  if (!startDate || !endDate) return 0;

  const start = new Date(startDate);
  const end = new Date(endDate);

  if (isNaN(start.getTime()) || isNaN(end.getTime())) return 0;

  const timeDiff = end.getTime() - start.getTime();
  return Math.ceil(timeDiff / (1000 * 3600 * 24));
}

/**
 * 判断是否为有效日期
 * @param {any} date - 待检查的日期
 * @returns {boolean} 是否为有效日期
 */
export function isValidDate(date) {
  if (!date) return false;
  const d = new Date(date);
  return !isNaN(d.getTime());
}
// 判断是否闰年
function isLeapYear(year) {
  return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
}
// 计算两个日期之间相差的天数(兼容Safari)
export function getDayDiff(startDate, endDate) {
  if (!startDate || !endDate) {
    return "";
  }
  // 将日期格式统一转换为 yyyy/MM/dd
  const start = startDate.replace(/-/g, "/");
  const end = endDate.replace(/-/g, "/");

  // 创建日期对象并设置时间为00:00:00
  const startTime = new Date(start);
  startTime.setHours(0, 0, 0, 0);
  const endTime = new Date(end);
  endTime.setHours(0, 0, 0, 0);

  // 处理跨年情况,计算时间差(毫秒)
  const yearDiff = endTime.getFullYear() - startTime.getFullYear();
  let days = 0;

  if (yearDiff > 0) {
    // 计算整年的天数
    for (let i = 0; i < yearDiff; i++) {
      const year = startTime.getFullYear() + i;
      days += isLeapYear(year) ? 366 : 365;
    }

    // 加上最后一年的剩余天数
    const lastYearStart = new Date(endTime.getFullYear(), 0, 1);
    const remainingDays = Math.floor(
      (endTime - lastYearStart) / (1000 * 60 * 60 * 24)
    );
    days += remainingDays;

    // 减去第一年已过天数
    const firstYearStart = new Date(startTime.getFullYear(), 0, 1);
    const firstYearDays = Math.floor(
      (startTime - firstYearStart) / (1000 * 60 * 60 * 24)
    );
    days -= firstYearDays;
  } else {
    // 同年直接计算天数差
    days = Math.floor((endTime - startTime) / (1000 * 60 * 60 * 24));
  }

  // 加1天以包含起始日期
  days = days + 1;

  return days > 0 ? `（${days}天）` : "";
}
